//+------------------------------------------------------------------+
//|                                              securitybaseapi.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <WinAPI/windef.h>
#include <WinAPI/winnt.h>

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#import "advapi32.dll"
/// 检查访问权限
/// @param security_descriptor 安全描述符
/// @param client_token 客户端令牌
/// @param desired_access 期望的访问权限
/// @param generic_mapping 通用映射
/// @param privilege_set 权限集
/// @param privilege_set_length 权限集长度
/// @param granted_access 授予的访问权限
/// @param access_status 访问状态
/// @return 操作结果
int AccessCheck(SECURITY_DESCRIPTOR &security_descriptor, HANDLE client_token, uint desired_access, 
                GENERIC_MAPPING &generic_mapping, PRIVILEGE_SET &privilege_set, uint &privilege_set_length, 
                uint &granted_access, int &access_status);

/// 访问检查并审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param object_type_name 对象类型名称
/// @param object_name 对象名称
/// @param security_descriptor 安全描述符
/// @param desired_access 期望的访问权限
/// @param generic_mapping 通用映射
/// @param object_creation 对象创建标志
/// @param granted_access 授予的访问权限
/// @param access_status 访问状态
/// @param generate_on_close 关闭时生成标志
/// @return 操作结果
int AccessCheckAndAuditAlarmW(const string subsystem_name, PVOID handle_id, string object_type_name, 
                              string object_name, SECURITY_DESCRIPTOR &security_descriptor, uint desired_access, 
                              GENERIC_MAPPING &generic_mapping, int object_creation, uint &granted_access, 
                              int &access_status, int &generate_on_close);

/// 按类型访问检查
/// @param security_descriptor 安全描述符
/// @param principal_self_sid 主体自身SID
/// @param client_token 客户端令牌
/// @param desired_access 期望的访问权限
/// @param object_type_list 对象类型列表
/// @param object_type_list_length 对象类型列表长度
/// @param generic_mapping 通用映射
/// @param privilege_set 权限集
/// @param privilege_set_length 权限集长度
/// @param granted_access 授予的访问权限
/// @param access_status 访问状态
/// @return 操作结果
int AccessCheckByType(SECURITY_DESCRIPTOR &security_descriptor, SID &principal_self_sid, HANDLE client_token, 
                      uint desired_access, OBJECT_TYPE_LIST &object_type_list, uint object_type_list_length, 
                      GENERIC_MAPPING &generic_mapping, PRIVILEGE_SET &privilege_set, uint &privilege_set_length, 
                      uint &granted_access, int &access_status);

/// 按类型访问检查结果列表
/// @param security_descriptor 安全描述符
/// @param principal_self_sid 主体自身SID
/// @param client_token 客户端令牌
/// @param desired_access 期望的访问权限
/// @param object_type_list 对象类型列表
/// @param object_type_list_length 对象类型列表长度
/// @param generic_mapping 通用映射
/// @param privilege_set 权限集
/// @param privilege_set_length 权限集长度
/// @param granted_access_list 授予的访问权限列表
/// @param access_status_list 访问状态列表
/// @return 操作结果
int AccessCheckByTypeResultList(SECURITY_DESCRIPTOR &security_descriptor, SID &principal_self_sid, HANDLE client_token, 
                                uint desired_access, OBJECT_TYPE_LIST &object_type_list, uint object_type_list_length, 
                                GENERIC_MAPPING &generic_mapping, PRIVILEGE_SET &privilege_set, uint &privilege_set_length, 
                                uint &granted_access_list, uint &access_status_list);

/// 按类型访问检查并审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param object_type_name 对象类型名称
/// @param object_name 对象名称
/// @param security_descriptor 安全描述符
/// @param principal_self_sid 主体自身SID
/// @param desired_access 期望的访问权限
/// @param audit_type 审计类型
/// @param flags 标志
/// @param object_type_list 对象类型列表
/// @param object_type_list_length 对象类型列表长度
/// @param generic_mapping 通用映射
/// @param object_creation 对象创建标志
/// @param granted_access 授予的访问权限
/// @param access_status 访问状态
/// @param generate_on_close 关闭时生成标志
/// @return 操作结果
int AccessCheckByTypeAndAuditAlarmW(const string subsystem_name, PVOID handle_id, const string object_type_name, 
                                    const string object_name, SECURITY_DESCRIPTOR &security_descriptor, SID &principal_self_sid, 
                                    uint desired_access, AUDIT_EVENT_TYPE audit_type, uint flags, OBJECT_TYPE_LIST &object_type_list, 
                                    uint object_type_list_length, GENERIC_MAPPING &generic_mapping, int object_creation, 
                                    uint &granted_access, int &access_status, int &generate_on_close);

/// 按类型访问检查结果列表并审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param object_type_name 对象类型名称
/// @param object_name 对象名称
/// @param security_descriptor 安全描述符
/// @param principal_self_sid 主体自身SID
/// @param desired_access 期望的访问权限
/// @param audit_type 审计类型
/// @param flags 标志
/// @param object_type_list 对象类型列表
/// @param object_type_list_length 对象类型列表长度
/// @param generic_mapping 通用映射
/// @param object_creation 对象创建标志
/// @param granted_access_list 授予的访问权限列表
/// @param access_status_list 访问状态列表
/// @param generate_on_close 关闭时生成标志
/// @return 操作结果
int AccessCheckByTypeResultListAndAuditAlarmW(const string subsystem_name, PVOID handle_id, const string object_type_name, 
                                              const string object_name, SECURITY_DESCRIPTOR &security_descriptor, SID &principal_self_sid, 
                                              uint desired_access, AUDIT_EVENT_TYPE audit_type, uint flags, OBJECT_TYPE_LIST &object_type_list, 
                                              uint object_type_list_length, GENERIC_MAPPING &generic_mapping, int object_creation, 
                                              uint &granted_access_list, uint &access_status_list, int &generate_on_close);

/// 按类型访问检查结果列表并通过句柄审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param client_token 客户端令牌
/// @param object_type_name 对象类型名称
/// @param object_name 对象名称
/// @param security_descriptor 安全描述符
/// @param principal_self_sid 主体自身SID
/// @param desired_access 期望的访问权限
/// @param audit_type 审计类型
/// @param flags 标志
/// @param object_type_list 对象类型列表
/// @param object_type_list_length 对象类型列表长度
/// @param generic_mapping 通用映射
/// @param object_creation 对象创建标志
/// @param granted_access_list 授予的访问权限列表
/// @param access_status_list 访问状态列表
/// @param generate_on_close 关闭时生成标志
/// @return 操作结果
int AccessCheckByTypeResultListAndAuditAlarmByHandleW(const string subsystem_name, PVOID handle_id, HANDLE client_token, 
                                                     const string object_type_name, const string object_name, SECURITY_DESCRIPTOR &security_descriptor, 
                                                     SID &principal_self_sid, uint desired_access, AUDIT_EVENT_TYPE audit_type, uint flags, 
                                                     OBJECT_TYPE_LIST &object_type_list, uint object_type_list_length, GENERIC_MAPPING &generic_mapping, 
                                                     int object_creation, uint &granted_access_list, uint &access_status_list, int &generate_on_close);

/// 添加允许访问的ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @return 操作结果
int AddAccessAllowedAce(ACL &acl, uint ace_revision, uint access_mask, SID &sid);

/// 添加允许访问的ACE(扩展)
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @return 操作结果
int AddAccessAllowedAceEx(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, SID &sid);

/// 添加允许访问的对象ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param object_type_guid 对象类型GUID
/// @param inherited_object_type_guid 继承的对象类型GUID
/// @param sid 安全标识符
/// @return 操作结果
int AddAccessAllowedObjectAce(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, 
                              GUID &object_type_guid, GUID &inherited_object_type_guid, SID &sid);

/// 添加拒绝访问的ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @return 操作结果
int AddAccessDeniedAce(ACL &acl, uint ace_revision, uint access_mask, SID &sid);

/// 添加拒绝访问的ACE(扩展)
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @return 操作结果
int AddAccessDeniedAceEx(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, SID &sid);

/// 添加拒绝访问的对象ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param object_type_guid 对象类型GUID
/// @param inherited_object_type_guid 继承的对象类型GUID
/// @param sid 安全标识符
/// @return 操作结果
int AddAccessDeniedObjectAce(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, 
                             GUID &object_type_guid, GUID &inherited_object_type_guid, SID &sid);

/// 添加ACE到ACL
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param starting_ace_index 起始ACE索引
/// @param ace_list ACE列表
/// @param ace_list_length ACE列表长度
/// @return 操作结果
int AddAce(ACL &acl, uint ace_revision, uint starting_ace_index, PVOID ace_list, uint ace_list_length);

/// 添加审计访问ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @param audit_success 审计成功
/// @param audit_failure 审计失败
/// @return 操作结果
int AddAuditAccessAce(ACL &acl, uint ace_revision, uint access_mask, SID &sid, int audit_success, int audit_failure);

/// 添加审计访问ACE(扩展)
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @param audit_success 审计成功
/// @param audit_failure 审计失败
/// @return 操作结果
int AddAuditAccessAceEx(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, 
                        SID &sid, int audit_success, int audit_failure);

/// 添加审计访问对象ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param object_type_guid 对象类型GUID
/// @param inherited_object_type_guid 继承的对象类型GUID
/// @param sid 安全标识符
/// @param audit_success 审计成功
/// @param audit_failure 审计失败
/// @return 操作结果
int AddAuditAccessObjectAce(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, 
                            GUID &object_type_guid, GUID &inherited_object_type_guid, SID &sid, 
                            int audit_success, int audit_failure);

/// 添加强制完整性ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param mandatory_policy 强制策略
/// @param label_sid 标签SID
/// @return 操作结果
int AddMandatoryAce(ACL &acl, uint ace_revision, uint ace_flags, uint mandatory_policy, SID &label_sid);

/// 调整令牌组
/// @param token_handle 令牌句柄
/// @param reset_to_default 重置为默认值
/// @param new_state 新状态
/// @param buffer_length 缓冲区长度
/// @param previous_state 先前状态
/// @param return_length 返回长度
/// @return 操作结果
int AdjustTokenGroups(HANDLE token_handle, int reset_to_default, TOKEN_GROUPS &new_state, 
                      uint buffer_length, TOKEN_GROUPS &previous_state, uint &return_length);

/// 调整令牌权限
/// @param token_handle 令牌句柄
/// @param disable_all_privileges 禁用所有权限
/// @param new_state 新状态
/// @param buffer_length 缓冲区长度
/// @param previous_state 先前状态
/// @param return_length 返回长度
/// @return 操作结果
int AdjustTokenPrivileges(HANDLE token_handle, int disable_all_privileges, TOKEN_PRIVILEGES &new_state, 
                          uint buffer_length, TOKEN_PRIVILEGES &previous_state, uint &return_length);

/// 分配并初始化SID
/// @param identifier_authority 标识符授权
/// @param sub_authority_count 子授权数量
/// @param sub_authority0 子授权0
/// @param sub_authority1 子授权1
/// @param sub_authority2 子授权2
/// @param sub_authority3 子授权3
/// @param sub_authority4 子授权4
/// @param sub_authority5 子授权5
/// @param sub_authority6 子授权6
/// @param sub_authority7 子授权7
/// @param sid 安全标识符
/// @return 操作结果
int AllocateAndInitializeSid(SID_IDENTIFIER_AUTHORITY &identifier_authority, uchar sub_authority_count, 
                             uint sub_authority0, uint sub_authority1, uint sub_authority2, uint sub_authority3, 
                             uint sub_authority4, uint sub_authority5, uint sub_authority6, uint sub_authority7, 
                             SID &sid);

/// 分配本地唯一ID
/// @param luid 本地唯一ID
/// @return 操作结果
int AllocateLocallyUniqueId(LUID &luid);

/// 检查是否授予所有访问权限
/// @param granted_access 授予的访问权限
/// @param desired_access 期望的访问权限
/// @return 是否授予所有访问权限
int AreAllAccessesGranted(uint granted_access, uint desired_access);

/// 检查是否授予任何访问权限
/// @param granted_access 授予的访问权限
/// @param desired_access 期望的访问权限
/// @return 是否授予任何访问权限
int AreAnyAccessesGranted(uint granted_access, uint desired_access);

/// 检查令牌成员资格
/// @param token_handle 令牌句柄
/// @param sid_to_check 要检查的SID
/// @param is_member 是否为成员
/// @return 操作结果
int CheckTokenMembership(HANDLE token_handle, SID &sid_to_check, int &is_member);

/// 转换为自动继承私有对象安全
/// @param parent_descriptor 父描述符
/// @param current_security_descriptor 当前安全描述符
/// @param new_security_descriptor 新安全描述符
/// @param object_type 对象类型
/// @param is_directory_object 是否为目录对象
/// @param generic_mapping 通用映射
/// @return 操作结果
int ConvertToAutoInheritPrivateObjectSecurity(SECURITY_DESCRIPTOR &parent_descriptor, 
                                               SECURITY_DESCRIPTOR &current_security_descriptor, 
                                               SECURITY_DESCRIPTOR &new_security_descriptor, 
                                               GUID &object_type, uchar is_directory_object, 
                                               GENERIC_MAPPING &generic_mapping);

/// 复制SID
/// @param destination_sid_length 目标SID长度
/// @param destination_sid 目标SID
/// @param source_sid 源SID
/// @return 操作结果
int CopySid(uint destination_sid_length, SID &destination_sid, SID &source_sid);

/// 创建私有对象安全
/// @param parent_descriptor 父描述符
/// @param creator_descriptor 创建者描述符
/// @param new_descriptor 新描述符
/// @param is_directory_object 是否为目录对象
/// @param token 令牌
/// @param generic_mapping 通用映射
/// @return 操作结果
int CreatePrivateObjectSecurity(SECURITY_DESCRIPTOR &parent_descriptor, 
                                SECURITY_DESCRIPTOR &creator_descriptor, 
                                SECURITY_DESCRIPTOR &new_descriptor, 
                                int is_directory_object, HANDLE token, 
                                GENERIC_MAPPING &generic_mapping);

/// 创建私有对象安全(扩展)
/// @param parent_descriptor 父描述符
/// @param creator_descriptor 创建者描述符
/// @param new_descriptor 新描述符
/// @param object_type 对象类型
/// @param is_container_object 是否为容器对象
/// @param auto_inherit_flags 自动继承标志
/// @param token 令牌
/// @param generic_mapping 通用映射
/// @return 操作结果
int CreatePrivateObjectSecurityEx(SECURITY_DESCRIPTOR &parent_descriptor, 
                                  SECURITY_DESCRIPTOR &creator_descriptor, 
                                  SECURITY_DESCRIPTOR &new_descriptor, 
                                  GUID &object_type, int is_container_object, 
                                  uint auto_inherit_flags, HANDLE token, 
                                  GENERIC_MAPPING &generic_mapping);

/// 创建多继承私有对象安全
/// @param parent_descriptor 父描述符
/// @param creator_descriptor 创建者描述符
/// @param new_descriptor 新描述符
/// @param object_types 对象类型
/// @param guid_count GUID数量
/// @param is_container_object 是否为容器对象
/// @param auto_inherit_flags 自动继承标志
/// @param token 令牌
/// @param generic_mapping 通用映射
/// @return 操作结果
int CreatePrivateObjectSecurityWithMultipleInheritance(SECURITY_DESCRIPTOR &parent_descriptor, 
                                                      SECURITY_DESCRIPTOR &creator_descriptor, 
                                                      SECURITY_DESCRIPTOR &new_descriptor, 
                                                      GUID &object_types, uint guid_count, 
                                                      int is_container_object, uint auto_inherit_flags, 
                                                      HANDLE token, GENERIC_MAPPING &generic_mapping);

/// 创建受限令牌
/// @param existing_token_handle 现有令牌句柄
/// @param flags 标志
/// @param disable_sid_count 禁用SID数量
/// @param sids_to_disable 要禁用的SID
/// @param delete_privilege_count 删除权限数量
/// @param privileges_to_delete 要删除的权限
/// @param restricted_sid_count 受限SID数量
/// @param sids_to_restrict 要限制的SID
/// @param new_token_handle 新令牌句柄
/// @return 操作结果
int CreateRestrictedToken(HANDLE existing_token_handle, uint flags, uint disable_sid_count, 
                          SID_AND_ATTRIBUTES &sids_to_disable, uint delete_privilege_count, 
                          LUID_AND_ATTRIBUTES &privileges_to_delete, uint restricted_sid_count, 
                          SID_AND_ATTRIBUTES &sids_to_restrict, HANDLE &new_token_handle);

/// 创建已知SID
/// @param well_known_sid_type 已知SID类型
/// @param domain_sid 域SID
/// @param sid 安全标识符
/// @param sid_size SID大小
/// @return 操作结果
int CreateWellKnownSid(WELL_KNOWN_SID_TYPE well_known_sid_type, SID &domain_sid, SID &sid, uint &sid_size);

/// 比较域SID是否相等
/// @param sid1 安全标识符1
/// @param sid2 安全标识符2
/// @param equal 是否相等
/// @return 操作结果
int EqualDomainSid(SID &sid1, SID &sid2, int &equal);

/// 删除ACE
/// @param acl 访问控制列表
/// @param ace_index ACE索引
/// @return 操作结果
int DeleteAce(ACL &acl, uint ace_index);

/// 销毁私有对象安全
/// @param object_descriptor 对象描述符
/// @return 操作结果
int DestroyPrivateObjectSecurity(SECURITY_DESCRIPTOR &object_descriptor);

/// 复制令牌
/// @param existing_token_handle 现有令牌句柄
/// @param impersonation_level 模拟级别
/// @param duplicate_token_handle 复制的令牌句柄
/// @return 操作结果
int DuplicateToken(HANDLE existing_token_handle, SECURITY_IMPERSONATION_LEVEL impersonation_level, HANDLE &duplicate_token_handle);

/// 复制令牌(扩展)
/// @param existing_token 现有令牌
/// @param desired_access 期望的访问权限
/// @param token_attributes 令牌属性
/// @param impersonation_level 模拟级别
/// @param token_type 令牌类型
/// @param new_token 新令牌
/// @return 操作结果
int DuplicateTokenEx(HANDLE existing_token, uint desired_access, PVOID token_attributes, 
                     SECURITY_IMPERSONATION_LEVEL impersonation_level, TOKEN_TYPE token_type, HANDLE &new_token);

/// 比较前缀SID是否相等
/// @param sid1 安全标识符1
/// @param sid2 安全标识符2
/// @return 是否相等
int EqualPrefixSid(SID &sid1, SID &sid2);

/// 比较SID是否相等
/// @param sid1 安全标识符1
/// @param sid2 安全标识符2
/// @return 是否相等
int EqualSid(SID &sid1, SID &sid2);

/// 查找第一个空闲ACE
/// @param acl 访问控制列表
/// @param ace ACE指针
/// @return 操作结果
int FindFirstFreeAce(ACL &acl, PVOID &ace);

/// 释放SID
/// @param sid 安全标识符
/// @return 操作结果
PVOID FreeSid(SID &sid);

/// 获取ACE
/// @param acl 访问控制列表
/// @param ace_index ACE索引
/// @param ace ACE指针
/// @return 操作结果
int GetAce(ACL &acl, uint ace_index, PVOID &ace);

/// 获取ACL信息
/// @param acl 访问控制列表
/// @param acl_information ACL信息
/// @param acl_information_length ACL信息长度
/// @param acl_information_class ACL信息类
/// @return 操作结果
int GetAclInformation(ACL &acl, PVOID acl_information, uint acl_information_length, ACL_INFORMATION_CLASS acl_information_class);

/// 获取文件安全
/// @param file_name 文件名
/// @param requested_information 请求的信息
/// @param security_descriptor 安全描述符
/// @param length 长度
/// @param length_needed 需要的长度
/// @return 操作结果
int GetFileSecurityW(const string file_name, uint requested_information, SECURITY_DESCRIPTOR &security_descriptor, uint length, uint &length_needed);

/// 获取内核对象安全
/// @param handle 句柄
/// @param requested_information 请求的信息
/// @param security_descriptor 安全描述符
/// @param length 长度
/// @param length_needed 需要的长度
/// @return 操作结果
int GetKernelObjectSecurity(HANDLE handle, uint requested_information, SECURITY_DESCRIPTOR &security_descriptor, uint length, uint &length_needed);

/// 获取SID长度
/// @param sid 安全标识符
/// @return SID长度
uint GetLengthSid(SID &sid);

/// 获取私有对象安全
/// @param object_descriptor 对象描述符
/// @param security_information 安全信息
/// @param resultant_descriptor 结果描述符
/// @param descriptor_length 描述符长度
/// @param return_length 返回长度
/// @return 操作结果
int GetPrivateObjectSecurity(SECURITY_DESCRIPTOR &object_descriptor, uint security_information, 
                             SECURITY_DESCRIPTOR &resultant_descriptor, uint descriptor_length, uint &return_length);

/// 获取安全描述符控制信息
/// @param security_descriptor 安全描述符
/// @param control 控制信息
/// @param revision 修订版本
/// @return 操作结果
int GetSecurityDescriptorControl(SECURITY_DESCRIPTOR &security_descriptor, ushort &control, uint &revision);

/// 获取安全描述符DACL
/// @param security_descriptor 安全描述符
/// @param dacl_present DACL存在标志
/// @param dacl DACL
/// @param dacl_defaulted DACL默认标志
/// @return 操作结果
int GetSecurityDescriptorDacl(SECURITY_DESCRIPTOR &security_descriptor, int &dacl_present, ACL &dacl, int &dacl_defaulted);

/// 获取安全描述符组
/// @param security_descriptor 安全描述符
/// @param group 组
/// @param group_defaulted 组默认标志
/// @return 操作结果
int GetSecurityDescriptorGroup(SECURITY_DESCRIPTOR &security_descriptor, SID &group, int &group_defaulted);

/// 获取安全描述符长度
/// @param security_descriptor 安全描述符
/// @return 安全描述符长度
uint GetSecurityDescriptorLength(SECURITY_DESCRIPTOR &security_descriptor);

/// 获取安全描述符所有者
/// @param security_descriptor 安全描述符
/// @param owner 所有者
/// @param owner_defaulted 所有者默认标志
/// @return 操作结果
int GetSecurityDescriptorOwner(SECURITY_DESCRIPTOR &security_descriptor, SID &owner, int &owner_defaulted);

/// 获取安全描述符RM控制
/// @param security_descriptor 安全描述符
/// @param rm_control RM控制
/// @return 操作结果
uint GetSecurityDescriptorRMControl(SECURITY_DESCRIPTOR &security_descriptor, uchar &rm_control);

/// 获取安全描述符SACL
/// @param security_descriptor 安全描述符
/// @param sacl_present SACL存在标志
/// @param sacl SACL
/// @param sacl_defaulted SACL默认标志
/// @return 操作结果
int GetSecurityDescriptorSacl(SECURITY_DESCRIPTOR &security_descriptor, int &sacl_present, ACL &sacl, int &sacl_defaulted);

/// 获取SID标识符授权
/// @param sid 安全标识符
/// @return 标识符授权
PVOID GetSidIdentifierAuthority(SID &sid);

/// 获取SID所需长度
/// @param sub_authority_count 子授权数量
/// @return SID长度
uint GetSidLengthRequired(uchar sub_authority_count);

/// 获取SID子授权
/// @param sid 安全标识符
/// @param sub_authority 子授权索引
/// @return 子授权值
PVOID GetSidSubAuthority(SID &sid, uint sub_authority);

/// 获取SID子授权计数
/// @param sid 安全标识符
/// @return 子授权计数
PVOID GetSidSubAuthorityCount(SID &sid);

/// 获取令牌信息
/// @param token_handle 令牌句柄
/// @param token_information_class 令牌信息类
/// @param token_information 令牌信息
/// @param token_information_length 令牌信息长度
/// @param return_length 返回长度
/// @return 操作结果
int GetTokenInformation(HANDLE token_handle, TOKEN_INFORMATION_CLASS token_information_class, 
                        PVOID &token_information, uint token_information_length, uint &return_length);

/// 获取Windows账户域SID
/// @param sid 安全标识符
/// @param domain_sid 域SID
/// @param domain_sid_size 域SID大小
/// @return 操作结果
int GetWindowsAccountDomainSid(SID &sid, SID &domain_sid, uint &domain_sid_size);

/// 模拟匿名令牌
/// @param thread_handle 线程句柄
/// @return 操作结果
int ImpersonateAnonymousToken(HANDLE thread_handle);

/// 模拟登录用户
/// @param token 令牌
/// @return 操作结果
int ImpersonateLoggedOnUser(HANDLE token);

/// 模拟自身
/// @param impersonation_level 模拟级别
/// @return 操作结果
int ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL impersonation_level);

/// 初始化ACL
/// @param acl 访问控制列表
/// @param acl_length ACL长度
/// @param acl_revision ACL修订版本
/// @return 操作结果
int InitializeAcl(ACL &acl, uint acl_length, uint acl_revision);

/// 初始化安全描述符
/// @param security_descriptor 安全描述符
/// @param revision 修订版本
/// @return 操作结果
int InitializeSecurityDescriptor(SECURITY_DESCRIPTOR &security_descriptor, uint revision);

/// 初始化SID
/// @param sid 安全标识符
/// @param identifier_authority 标识符授权
/// @param sub_authority_count 子授权数量
/// @return 操作结果
int InitializeSid(SID &sid, SID_IDENTIFIER_AUTHORITY &identifier_authority, uchar sub_authority_count);

/// 检查令牌是否受限
/// @param token_handle 令牌句柄
/// @return 是否受限
int IsTokenRestricted(HANDLE token_handle);

/// 检查ACL是否有效
/// @param acl 访问控制列表
/// @return 是否有效
int IsValidAcl(ACL &acl);

/// 检查安全描述符是否有效
/// @param security_descriptor 安全描述符
/// @return 是否有效
int IsValidSecurityDescriptor(SECURITY_DESCRIPTOR &security_descriptor);

/// 检查SID是否有效
/// @param sid 安全标识符
/// @return 是否有效
int IsValidSid(SID &sid);

/// 检查是否为已知SID
/// @param sid 安全标识符
/// @param well_known_sid_type 已知SID类型
/// @return 是否为已知SID
int IsWellKnownSid(SID &sid, WELL_KNOWN_SID_TYPE well_known_sid_type);

/// 创建绝对安全描述符
/// @param self_relative_security_descriptor 自相关安全描述符
/// @param absolute_security_descriptor 绝对安全描述符
/// @param absolute_security_descriptor_size 绝对安全描述符大小
/// @param dacl DACL
/// @param dacl_size DACL大小
/// @param sacl SACL
/// @param sacl_size SACL大小
/// @param owner 所有者
/// @param owner_size 所有者大小
/// @param primary_group 主组
/// @param primary_group_size 主组大小
/// @return 操作结果
int MakeAbsoluteSD(SECURITY_DESCRIPTOR &self_relative_security_descriptor, 
                   SECURITY_DESCRIPTOR &absolute_security_descriptor, 
                   uint &absolute_security_descriptor_size, ACL &dacl, uint &dacl_size, 
                   ACL &sacl, uint &sacl_size, SID &owner, uint &owner_size, 
                   SID &primary_group, uint &primary_group_size);

/// 创建自相关安全描述符
/// @param absolute_security_descriptor 绝对安全描述符
/// @param self_relative_security_descriptor 自相关安全描述符
/// @param buffer_length 缓冲区长度
/// @return 操作结果
int MakeSelfRelativeSD(SECURITY_DESCRIPTOR &absolute_security_descriptor, 
                       SECURITY_DESCRIPTOR &self_relative_security_descriptor, 
                       uint &buffer_length);

/// 映射通用掩码
/// @param access_mask 访问掩码
/// @param generic_mapping 通用映射
void MapGenericMask(uint &access_mask, GENERIC_MAPPING &generic_mapping);

/// 对象关闭审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param generate_on_close 关闭时生成标志
/// @return 操作结果
int ObjectCloseAuditAlarmW(const string subsystem_name, PVOID handle_id, int generate_on_close);

/// 对象删除审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param generate_on_close 关闭时生成标志
/// @return 操作结果
int ObjectDeleteAuditAlarmW(const string subsystem_name, PVOID handle_id, int generate_on_close);

/// 对象打开审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param object_type_name 对象类型名称
/// @param object_name 对象名称
/// @param security_descriptor 安全描述符
/// @param client_token 客户端令牌
/// @param desired_access 期望的访问权限
/// @param granted_access 授予的访问权限
/// @param privileges 权限
/// @param object_creation 对象创建标志
/// @param access_granted 访问授予标志
/// @param generate_on_close 关闭时生成标志
/// @return 操作结果
int ObjectOpenAuditAlarmW(const string subsystem_name, PVOID handle_id, string object_type_name, 
                          string object_name, SECURITY_DESCRIPTOR &security_descriptor, HANDLE client_token, 
                          uint desired_access, uint granted_access, PRIVILEGE_SET &privileges, 
                          int object_creation, int access_granted, int &generate_on_close);

/// 对象权限审计警报
/// @param subsystem_name 子系统名称
/// @param handle_id 句柄ID
/// @param client_token 客户端令牌
/// @param desired_access 期望的访问权限
/// @param privileges 权限
/// @param access_granted 访问授予标志
/// @return 操作结果
int ObjectPrivilegeAuditAlarmW(const string subsystem_name, PVOID handle_id, HANDLE client_token, 
                               uint desired_access, PRIVILEGE_SET &privileges, int access_granted);

/// 权限检查
/// @param client_token 客户端令牌
/// @param required_privileges 所需权限
/// @param result 结果
/// @return 操作结果
int PrivilegeCheck(HANDLE client_token, PRIVILEGE_SET &required_privileges, int &result);

/// 特权服务审计警报
/// @param subsystem_name 子系统名称
/// @param service_name 服务名称
/// @param client_token 客户端令牌
/// @param privileges 权限
/// @param access_granted 访问授予标志
/// @return 操作结果
int PrivilegedServiceAuditAlarmW(const string subsystem_name, const string service_name, 
                                 HANDLE client_token, PRIVILEGE_SET &privileges, int access_granted);

/// 查询安全访问掩码
/// @param security_information 安全信息
/// @param desired_access 期望的访问权限
void QuerySecurityAccessMask(uint security_information, uint &desired_access);

/// 恢复为自身
/// @return 操作结果
int RevertToSelf(void);

/// 设置ACL信息
/// @param acl 访问控制列表
/// @param acl_information ACL信息
/// @param acl_information_length ACL信息长度
/// @param acl_information_class ACL信息类
/// @return 操作结果
int SetAclInformation(ACL &acl, PVOID acl_information, uint acl_information_length, ACL_INFORMATION_CLASS acl_information_class);

/// 设置文件安全
/// @param file_name 文件名
/// @param security_information 安全信息
/// @param security_descriptor 安全描述符
/// @return 操作结果
int SetFileSecurityW(const string file_name, uint security_information, SECURITY_DESCRIPTOR &security_descriptor);

/// 设置内核对象安全
/// @param handle 句柄
/// @param security_information 安全信息
/// @param security_descriptor 安全描述符
/// @return 操作结果
int SetKernelObjectSecurity(HANDLE handle, uint security_information, SECURITY_DESCRIPTOR &security_descriptor);

/// 设置私有对象安全
/// @param security_information 安全信息
/// @param modification_descriptor 修改描述符
/// @param objects_security_descriptor 对象安全描述符
/// @param generic_mapping 通用映射
/// @param token 令牌
/// @return 操作结果
int SetPrivateObjectSecurity(uint security_information, SECURITY_DESCRIPTOR &modification_descriptor, 
                             SECURITY_DESCRIPTOR &objects_security_descriptor, GENERIC_MAPPING &generic_mapping, 
                             HANDLE token);

/// 设置私有对象安全(扩展)
/// @param security_information 安全信息
/// @param modification_descriptor 修改描述符
/// @param objects_security_descriptor 对象安全描述符
/// @param auto_inherit_flags 自动继承标志
/// @param generic_mapping 通用映射
/// @param token 令牌
/// @return 操作结果
int SetPrivateObjectSecurityEx(uint security_information, SECURITY_DESCRIPTOR &modification_descriptor, 
                               SECURITY_DESCRIPTOR &objects_security_descriptor, uint auto_inherit_flags, 
                               GENERIC_MAPPING &generic_mapping, HANDLE token);

/// 设置安全访问掩码
/// @param security_information 安全信息
/// @param desired_access 期望的访问权限
void SetSecurityAccessMask(uint security_information, uint &desired_access);

/// 设置安全描述符控制
/// @param security_descriptor 安全描述符
/// @param control_bits_of_interest 控制位感兴趣部分
/// @param control_bits_to_set 要设置的控制位
/// @return 操作结果
int SetSecurityDescriptorControl(SECURITY_DESCRIPTOR &security_descriptor, ushort control_bits_of_interest, ushort control_bits_to_set);

/// 设置安全描述符DACL
/// @param security_descriptor 安全描述符
/// @param dacl_present DACL存在标志
/// @param dacl DACL
/// @param dacl_defaulted DACL默认标志
/// @return 操作结果
int SetSecurityDescriptorDacl(SECURITY_DESCRIPTOR &security_descriptor, int dacl_present, ACL &dacl, int dacl_defaulted);

/// 设置安全描述符组
/// @param security_descriptor 安全描述符
/// @param group 组
/// @param group_defaulted 组默认标志
/// @return 操作结果
int SetSecurityDescriptorGroup(SECURITY_DESCRIPTOR &security_descriptor, SID &group, int group_defaulted);

/// 设置安全描述符所有者
/// @param security_descriptor 安全描述符
/// @param owner 所有者
/// @param owner_defaulted 所有者默认标志
/// @return 操作结果
int SetSecurityDescriptorOwner(SECURITY_DESCRIPTOR &security_descriptor, SID &owner, int owner_defaulted);

/// 设置安全描述符RM控制
/// @param security_descriptor 安全描述符
/// @param rm_control RM控制
/// @return 操作结果
uint SetSecurityDescriptorRMControl(SECURITY_DESCRIPTOR &security_descriptor, uchar &rm_control);

/// 设置安全描述符SACL
/// @param security_descriptor 安全描述符
/// @param sacl_present SACL存在标志
/// @param sacl SACL
/// @param sacl_defaulted SACL默认标志
/// @return 操作结果
int SetSecurityDescriptorSacl(SECURITY_DESCRIPTOR &security_descriptor, int sacl_present, ACL &sacl, int sacl_defaulted);

/// 设置令牌信息
/// @param token_handle 令牌句柄
/// @param token_information_class 令牌信息类
/// @param token_information 令牌信息
/// @param token_information_length 令牌信息长度
/// @return 操作结果
int SetTokenInformation(HANDLE token_handle, TOKEN_INFORMATION_CLASS token_information_class, PVOID token_information, uint token_information_length);

/// CVE事件写入
/// @param cve_id CVE ID
/// @param additional_details 附加细节
/// @return 操作结果
int CveEventWrite(const string cve_id, const string additional_details);
#import

#import "kernel32.dll"
/// 添加资源属性ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @param attribute_info 属性信息
/// @param return_length 返回长度
/// @return 操作结果
int AddResourceAttributeAce(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, 
                            SID &sid, CLAIM_SECURITY_ATTRIBUTES_INFORMATION &attribute_info, uint &return_length);

/// 添加范围策略ID ACE
/// @param acl 访问控制列表
/// @param ace_revision ACE修订版本
/// @param ace_flags ACE标志
/// @param access_mask 访问掩码
/// @param sid 安全标识符
/// @return 操作结果
int AddScopedPolicyIDAce(ACL &acl, uint ace_revision, uint ace_flags, uint access_mask, SID &sid);

/// 检查令牌能力
/// @param token_handle 令牌句柄
/// @param capability_sid_to_check 要检查的能力SID
/// @param has_capability 是否具有能力
/// @return 操作结果
int CheckTokenCapability(HANDLE token_handle, SID &capability_sid_to_check, int &has_capability);

/// 获取应用容器ACE
/// @param acl 访问控制列表
/// @param starting_ace_index 起始ACE索引
/// @param app_container_ace 应用容器ACE
/// @param app_container_ace_index 应用容器ACE索引
/// @return 操作结果
int GetAppContainerAce(ACL &acl, uint starting_ace_index, PVOID &app_container_ace, uint &app_container_ace_index);

/// 检查令牌成员资格(扩展)
/// @param token_handle 令牌句柄
/// @param sid_to_check 要检查的SID
/// @param flags 标志
/// @param is_member 是否为成员
/// @return 操作结果
int CheckTokenMembershipEx(HANDLE token_handle, SID &sid_to_check, uint flags, int &is_member);

/// 设置缓存签名级别
/// @param source_files 源文件
/// @param source_file_count 源文件数量
/// @param flags 标志
/// @param target_file 目标文件
/// @return 操作结果
int SetCachedSigningLevel(HANDLE &source_files, uint source_file_count, uint flags, HANDLE target_file);

/// 获取缓存签名级别
/// @param file 文件
/// @param flags 标志
/// @param signing_level 签名级别
/// @param thumbprint 指纹
/// @param thumbprint_size 指纹大小
/// @param thumbprint_algorithm 指纹算法
/// @return 操作结果
int GetCachedSigningLevel(HANDLE file, ulong flags, ulong signing_level, uchar &thumbprint[], ulong thumbprint_size, ulong thumbprint_algorithm);
#import
//+------------------------------------------------------------------+